/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package controladores;

import beans.Grupo;
import beans.Nota;
import beans.Usuario;
import com.opensymphony.xwork2.ActionSupport;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Map;
import org.apache.struts2.interceptor.SessionAware;

/**
 *
 * @author nahuel
 */
public class controlador extends ActionSupport implements SessionAware {

    private Map session;
    private String user;
    private String password;
    private String password2;
    private String descripcion;
    private String posicion;
    private String color;
    private String notaId;
    private String id;
    private String descripcion_modificar;
    private String posicion_modificar;
    private String color_modificar;
    private String nombre;
    private String grupo;
    private String Usuarios_grupo;
    private String grupoId;
    ArrayList<Nota> listaNotasToStudy = new ArrayList();
    ArrayList<Nota> listaNotasToRemember = new ArrayList();
    ArrayList<Nota> listaNotasToDo = new ArrayList();
    ArrayList<Grupo> listaGrupos = new ArrayList();
    ArrayList<Usuario> listaUsuarios = new ArrayList();

    /**
     * Este metodo permite conocer si un usuario pertenece o no al sistema
     * @return ERROR si no pertenece al sistema, SUCCESS si pertenece
     * @throws Exception 
     */
    public String exist() throws Exception {
        if (!getUser().isEmpty() && !getPassword().isEmpty()) {	//Verificamos que los datos no sean nulos
            Usuario usuario = Conexiones.getInstance().getUser(getUser());
            if (usuario != null && usuario.getContrasena().equals(getPassword())) {	//Si el usuario se encuentra se agrega a la sesion
                session.put("usuario", usuario);
                session.put("grupo", null);
            } else {					//Si no se encuentra se devuelve un error
                addActionError("No existe esta cuenta");
                return ERROR;
            }
        } else {
            addActionError("Inserte datos correctos");
            return ERROR;
        }
        this.refrescarContenido();
        return SUCCESS;
    }

    /**
     * Este metodo permite agregar un usuario al sistema
     * @return ERROR si no se pudo agregar el usuario al sistema, SUCCESS si se
     * agregó correctamente
     * @throws Exception 
     */
    public String registrarse() throws Exception {
        if (!getUser().isEmpty() && !getPassword().isEmpty() && !getPassword2().isEmpty()) {	//Verificamos que los datos no sean nulos
            Usuario usuario = Conexiones.getInstance().getUser(getUser());
            if (usuario != null) {	//Si existe un usuario con ese nombre
                addActionError("Ya existe este username");
                return ERROR;
            } else {					//Si no se encuentra un usuario con ese nombre
                if (getPassword().equals(getPassword2())) {
                    Usuario usuarioNuevo = new Usuario();
                    usuarioNuevo.setUsuario(getUser());
                    usuarioNuevo.setContrasena(getPassword());
                    Conexiones.getInstance().persist(usuarioNuevo);
                    addActionError("El usuario ha sido creado");
                    return SUCCESS;
                } else {
                    addActionError("Las contraseñas no coinciden");
                    return ERROR;
                }
            }
        } else {
            addActionError("Inserte datos correctos");
            return ERROR;
        }
    }
    
    /**
     * Este metodo desloguea al usuario y borra los datos guardados en session
     * @return 
     */
    public String salir(){
        session.clear();
        return SUCCESS;
    }

    /**
     * Este metodo permite refrescar los listados con los contenidos de la base 
     * de datos
     */
    public void refrescarContenido() {
        this.listarNotas();
        this.listarGrupos();
        this.listarUsuarios();
        if (session.get("grupo") != null) {
            grupo = ((Grupo) session.get("grupo")).getNombre();
        } else {
            grupo = "My Whiteboard";
        }
    }

    /**
     * Este metodo permite agregar una nota a la base de datos
     * @return SUCCESS si se agrego correctamente
     * @throws Exception 
     */
    public String agregarNota() throws Exception {
        Nota nota = new Nota();
        nota.setCategoria(getPosicion());
        nota.setNota(getDescripcion());
        nota.setColor(getColor());
        nota.setUsuario((Usuario) session.get("usuario"));
        nota.setGrupo((Grupo) session.get("grupo"));
        Conexiones.getInstance().persist(nota);
        this.refrescarContenido();
        return SUCCESS;
    }

    /**
     * Este metodo permite modificar una nota en la base de datos
     * @return SUCCESS si se agrego correctamente
     * @throws Exception 
     */
    public String modificarNota() throws Exception {
        Conexiones.getInstance().modificarNota(getId(), getPosicion_modificar(), getDescripcion_modificar(), getColor_modificar(), (Usuario) session.get("usuario"));
        this.refrescarContenido();
        return SUCCESS;
    }

    /**
     * Este metodo lista todas las notas que deben ser mostradas en la pizarra,
     * de acuerdo al usuario y grupo en el que se encuentra
     */
    public void listarNotas() {
        Usuario usuario = (Usuario) session.get("usuario");
        Conexiones.getInstance().getEntity().refresh(usuario);
        Grupo grupoActual = (Grupo) session.get("grupo");
        if (grupoActual == null) {
            Iterator<Nota> it = usuario.getNotas().iterator();
            while (it.hasNext()) {
                Nota nota = it.next();
                if (nota.getGrupo() == null) {
                    if (nota.getCategoria().equals("To Study")) {
                        listaNotasToStudy.add(nota);
                    } else {
                        if (nota.getCategoria().equals("To Remember")) {
                            listaNotasToRemember.add(nota);
                        } else {
                            if (nota.getCategoria().equals("To Do")) {
                                listaNotasToDo.add(nota);
                            }
                        }
                    }
                }
            }
        } else {
            Conexiones.getInstance().getEntity().refresh(grupoActual);
            Iterator<Nota> it2 = grupoActual.getNotas().iterator();
            while (it2.hasNext()) {
                Nota nota2 = it2.next();
                if (nota2.getCategoria().equals("To Study")) {
                    listaNotasToStudy.add(nota2);
                } else {
                    if (nota2.getCategoria().equals("To Remember")) {
                        listaNotasToRemember.add(nota2);
                    } else {
                        if (nota2.getCategoria().equals("To Do")) {
                            listaNotasToDo.add(nota2);
                        }
                    }
                }
            }
        }
    }

    /**
     * Este metodo permite eliminar una nota de la base de datos
     * @return 
     */
    public String eliminarNota() {
        if (Conexiones.getInstance().eliminarNota(notaId)) {
            this.refrescarContenido();
            return "eliminada";
        } else {
            addActionError("Error al eliminar la nota");
            return "error";
        }
    }

    /**
     * Este metodo permite crear un grupo y guardarlo en la base de datos
     * @return SUCCESS si el grupo se creo
     * @throws Exception 
     */
    public String agregarGrupo() throws Exception {
        Grupo grupo = new Grupo();
        grupo.setNombre(getNombre());
        grupo.setDuenio((Usuario) session.get("usuario"));
        Conexiones.getInstance().persist(grupo);
        if (getUsuarios_grupo() != null) {
            String[] temp = getUsuarios_grupo().split(",");
            for (int i = 0; i < temp.length; i++) {
                Usuario usuario = Conexiones.getInstance().getUser(temp[i].trim());
                if (usuario.getGrupos() == null) {
                    usuario.setGrupos(new ArrayList<Grupo>());
                }
                usuario.getGrupos().add(grupo);
                Conexiones.getInstance().persist(usuario);
            }
        }
        session.put("grupo", grupo);
        this.refrescarContenido();
        return SUCCESS;
    }

    /**
     * Este metodo lista todos los grupos que deben ser mostrados en la pizarra,
     * de acuerdo al usuario logueado
     */
    public void listarGrupos() {
        listaGrupos = new ArrayList();
        Usuario usuario = (Usuario) session.get("usuario");
        Conexiones.getInstance().getEntity().refresh(usuario);
        Iterator<Grupo> it = usuario.getMisgrupos().iterator();
        while (it.hasNext()) {
            listaGrupos.add(it.next());
        }
        Iterator<Grupo> it2 = usuario.getGrupos().iterator();
        while (it2.hasNext()) {
            listaGrupos.add(it2.next());
        }
    }

    /**
     * Este metodo coloca en session el grupo en el cual se encuentra el 
     * usuario logueado actualmente
     * @return 
     */
    public String mostrarGrupo() {
        this.listarGrupos();
        if (grupo.equals("My Whiteboard")) {
            session.put("grupo", null);
        } else {
            Iterator<Grupo> it = listaGrupos.iterator();
            while (it.hasNext()) {
                Grupo grupoActual = it.next();
                if (grupoActual.getNombre().equals(grupo)) {
                    session.put("grupo", grupoActual);
                }
            }
        }
        this.refrescarContenido();
        return SUCCESS;
    }

    /**
     * Este metodo permite eliminar un grupo de la base de datos, eliminando 
     * todas las notas que se crearon en el y todas las relaciones con los 
     * usuarios que pertenecen al mismo
     * @return SUCCESS si se elimino correctamente
     */
    public String eliminarGrupo() {
        Grupo grupo = Conexiones.getInstance().getGrupo(Long.parseLong(grupoId));
        Usuario usuarioActual = (Usuario) session.get("usuario");
        if (grupo.getDuenio().equals(usuarioActual)) {
            Iterator<Nota> it = grupo.getNotas().iterator();
            while (it.hasNext()) {
                Nota nota = it.next();
                Conexiones.getInstance().eliminarNota(nota);
            }
            Iterator<Usuario> it2 = grupo.getUsuarios().iterator();
            while (it2.hasNext()) {
                Usuario usuario = it2.next();
                usuario.getGrupos().remove(grupo);
                Conexiones.getInstance().persist(usuario);
            }
            Conexiones.getInstance().eliminarGrupo(grupo);
        } else {
            usuarioActual.getGrupos().remove(grupo);
            Conexiones.getInstance().persist(usuarioActual);
        }
        session.put("grupo", null);
        this.refrescarContenido();
        return SUCCESS;
    }

    /**
     * Este metodo permite obtener un listado de todos los usuarios del sistema
     * excepto el que se encuentra logueado actualmente
     */
    public void listarUsuarios() {
        listaUsuarios = Conexiones.getInstance().listarUsuarios();
        listaUsuarios.remove((Usuario) session.get("usuario"));
    }

    public ArrayList<Nota> getListaNotasToDo() {
        return listaNotasToDo;
    }

    public void setListaNotasToDo(ArrayList<Nota> listaNotasToDo) {
        this.listaNotasToDo = listaNotasToDo;
    }

    public ArrayList<Nota> getListaNotasToRemember() {
        return listaNotasToRemember;
    }

    public void setListaNotasToRemember(ArrayList<Nota> listaNotasToRemember) {
        this.listaNotasToRemember = listaNotasToRemember;
    }

    public ArrayList<Nota> getListaNotasToStudy() {
        return listaNotasToStudy;
    }

    public void setListaNotasToStudy(ArrayList<Nota> listaNotasToStudy) {
        this.listaNotasToStudy = listaNotasToStudy;
    }

    public Map getSession() {
        return session;
    }

    public void setSession(Map session) {
        this.session = session;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getPassword2() {
        return password2;
    }

    public void setPassword2(String password2) {
        this.password2 = password2;
    }

    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    public String getDescripcion() {
        return descripcion;
    }

    public void setDescripcion(String descripcion) {
        this.descripcion = descripcion;
    }

    public String getPosicion() {
        return posicion;
    }

    public void setPosicion(String posicion) {
        this.posicion = posicion;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getNotaId() {
        return notaId;
    }

    public void setNotaId(String notaId) {
        this.notaId = notaId;
    }

    public String getDescripcion_modificar() {
        return descripcion_modificar;
    }

    public void setDescripcion_modificar(String descripcion_modificar) {
        this.descripcion_modificar = descripcion_modificar;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getPosicion_modificar() {
        return posicion_modificar;
    }

    public void setPosicion_modificar(String posicion_modificar) {
        this.posicion_modificar = posicion_modificar;
    }

    public String getColor_modificar() {
        return color_modificar;
    }

    public void setColor_modificar(String color_modificar) {
        this.color_modificar = color_modificar;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public ArrayList<Grupo> getListaGrupos() {
        return listaGrupos;
    }

    public void setListaGrupos(ArrayList<Grupo> listaGrupos) {
        this.listaGrupos = listaGrupos;
    }

    public String getGrupo() {
        return grupo;
    }

    public void setGrupo(String grupo) {
        this.grupo = grupo;
    }

    public ArrayList<Usuario> getListaUsuarios() {
        return listaUsuarios;
    }

    public void setListaUsuarios(ArrayList<Usuario> listaUsuarios) {
        this.listaUsuarios = listaUsuarios;
    }

    public String getUsuarios_grupo() {
        return Usuarios_grupo;
    }

    public void setUsuarios_grupo(String Usuarios_grupo) {
        this.Usuarios_grupo = Usuarios_grupo;
    }

    public String getGrupoId() {
        return grupoId;
    }

    public void setGrupoId(String grupoId) {
        this.grupoId = grupoId;
    }
}
